home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / C / Applications / Moscow ML 1.31 / source code / mosml / src / runtime / stacks.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-07-03  |  3.2 KB  |  114 lines  |  [TEXT/R*ch]
  1. /* To initialize and resize the stacks */
  2.  
  3. #include "config.h"
  4. #include "debugger.h"
  5. #include "debugcom.h"
  6. #include "fail.h"
  7. #include "misc.h"
  8. #include "mlvalues.h"
  9. #include "stacks.h"
  10.  
  11. value * arg_stack_low;
  12. value * arg_stack_high;
  13. value * arg_stack_threshold;
  14. value * ret_stack_low;
  15. value * ret_stack_high;
  16. value * ret_stack_threshold;
  17. value * extern_asp;
  18. value * extern_rsp;
  19. struct trap_frame * tp;
  20. value global_data;
  21.  
  22. void init_stacks()
  23. {
  24.   arg_stack_low = (value *) stat_alloc(Arg_stack_size);
  25.   arg_stack_high = arg_stack_low + Arg_stack_size / sizeof (value);
  26.   arg_stack_threshold = arg_stack_low + Arg_stack_threshold / sizeof (value);
  27.   extern_asp = arg_stack_high;
  28.   ret_stack_low = (value *) stat_alloc(Ret_stack_size);
  29.   ret_stack_high = ret_stack_low + Ret_stack_size / sizeof (value);
  30.   ret_stack_threshold = ret_stack_low + Ret_stack_threshold / sizeof (value);
  31.   extern_rsp = ret_stack_high;
  32.   tp = (struct trap_frame *) ret_stack_high;
  33.   trap_barrier = ret_stack_high + 1;
  34. }
  35.  
  36. static void realloc_arg_stack()
  37. {        
  38.   asize_t size;
  39.   value * new_low, * new_high, * new_asp;
  40.   struct trap_frame * p;
  41.  
  42.   Assert(extern_asp >= arg_stack_low);
  43.   size = arg_stack_high - arg_stack_low;
  44.   if (size >= Max_arg_stack_size)
  45.     raise_out_of_memory();
  46.   size *= 2;
  47.   gc_message ("Growing argument stack to %ldk\n",
  48.           (long) size * sizeof(value) / 1024);
  49.   new_low = (value *) stat_alloc(size * sizeof(value));
  50.   new_high = new_low + size;
  51.  
  52. #define shift(ptr) \
  53.     ((char *) new_high - ((char *) arg_stack_high - (char *) (ptr)))
  54.  
  55.   new_asp = (value *) shift(extern_asp);
  56.   bcopy((char *) extern_asp,
  57.         (char *) new_asp,
  58.         (arg_stack_high - extern_asp) * sizeof(value));
  59.   stat_free((char *) arg_stack_low);
  60.   for (p = tp; p < (struct trap_frame *) ret_stack_high; p = p->tp)
  61.     p->asp = (value *) shift(p->asp);
  62.   arg_stack_low = new_low;
  63.   arg_stack_high = new_high;
  64.   arg_stack_threshold = arg_stack_low + Arg_stack_threshold / sizeof (value);
  65.   extern_asp = new_asp;
  66.  
  67. #undef shift
  68. }
  69.  
  70. static void realloc_ret_stack()
  71. {        
  72.   asize_t size;
  73.   value * new_low, * new_high, * new_rsp;
  74.   struct trap_frame * p;
  75.  
  76.   Assert(extern_rsp >= ret_stack_low);
  77.   size = ret_stack_high - ret_stack_low;
  78.   if (size >= Max_ret_stack_size)
  79.     raise_out_of_memory();
  80.   size *= 2;
  81.   gc_message ("Growing return stack to %ldk\n",
  82.           (long) size * sizeof(value) / 1024);
  83.   new_low = (value *) stat_alloc(size * sizeof(value));
  84.   new_high = new_low + size;
  85.  
  86. #define shift(ptr) \
  87.     ((char *) new_high - ((char *) ret_stack_high - (char *) (ptr)))
  88.  
  89.   new_rsp = (value *) shift(extern_rsp);
  90.   bcopy((char *) extern_rsp,
  91.         (char *) new_rsp,
  92.         (ret_stack_high - extern_rsp) * sizeof(value));
  93.   stat_free((char *) ret_stack_low);
  94.   tp = (struct trap_frame *) shift(tp);
  95.   for (p = tp; p < (struct trap_frame *) new_high; p = p->tp) {
  96.     p->tp = (struct trap_frame *) shift(p->tp);
  97.   }
  98.   trap_barrier = (value *) shift(trap_barrier);
  99.   ret_stack_low = new_low;
  100.   ret_stack_high = new_high;
  101.   ret_stack_threshold = ret_stack_low + Ret_stack_threshold / sizeof (value);
  102.   extern_rsp = new_rsp;
  103.  
  104. #undef shift
  105. }
  106.  
  107. void realloc_stacks()
  108. {
  109.   if (extern_rsp < ret_stack_threshold)
  110.     realloc_ret_stack();
  111.   if (extern_asp < arg_stack_threshold)
  112.     realloc_arg_stack();
  113. }
  114.